____ _ _ _ _
| _ \ ___ | |_ (_) _ __ ___ __| | (_) __ _
| |_) | / _ \ | __| | | | '_ \ / _ \ / _| | | | / _ |
| _ < | __/ | |_ | | | |_) | | __/ | (_| | | | | (_| |
|_| \_\ \___| \__| |_| | .__/ \___| \__,_| |_| \__,_|
|_|
- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b
ÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻ
BlockverschlĂźsselung
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ
top
Eine Blockverschlßsselung (auch Blockchiffre oder auf Englisch block cipher genannt) ist ein deterministisches Verschlßsselungsverfahren, das einen Klartextblock, d. h. einen Klartextabschnitt fester Länge, auf einen Geheimtext- oder Schlßsseltextblock fester (in der Regel der gleichen) Länge abbildet. Diese Abbildung wird dabei durch einen Schlßssel beeinflusst. Kennt man diesen, kann man aus dem Geheimtext wieder den Klartext berechnen, mit etwa dem gleichen Aufwand wie fßr das Verschlßsseln. Ohne Kenntnis des Schlßssels ist dies hingegen viel schwieriger, bei vielen modernen Blockchiffren ist dafßr keine praktikable Methode bekannt.
Im Gegensatz zu einer Stromchiffre kann eine Blockchiffre nur einen Block der gegebenen Länge verschlßsseln, wobei die Blocklänge typischerweise 64 Bit bis 256 Bit beträgt. Längere Texte werden auf ein Vielfaches der Blocklänge aufgefßllt und in BlÜcke geteilt, und es wird ein Betriebsmodus gewählt, der festlegt, wie die Blockchiffre darauf anzuwenden ist.
Blockchiffren werden auch als Bausteine zur Konstruktion weiterer kryptografischer Verfahren, z. B. kryptographischer Hashfunktionen, eingesetzt.
Contents
⢠Anforderungen
⢠Geschichte
⢠Feistelchiffre
⢠Primitive
⢠Weblinks
⢠Einzelnachweise
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ
Anforderungen
Eine Blockchiffre soll vielen Angriffsszenarien widerstehen. Wenn etwa ein Angreifer beliebig viele mit dem gleichen Schlßssel erzeugte Paare von Klar- und GeheimtextblÜcken vorliegen hat, soll es ihm dennoch nicht mÜglich sein, den Schlßssel zu ermitteln oder auf anderem Weg einen weiteren mit diesem Schlßssel erzeugten Geheimtext zu entziffern. Dies soll sogar dann noch gelten, wenn der Angreifer die KlartextblÜcke frei wählen kann, also zu jedem von ihm konstruierten Block den unter dem gegebenen Schlßssel zugehÜrigen Geheimtextblock erfahren kann. Auch dann, wenn der Angreifer wahlweise einen Klar- oder Geheimtextblock frei wählen kann, soll es ihm unmÜglich sein, den Schlßssel herauszufinden.
Dabei geht man davon aus, dass der Angreifer den internen Aufbau der VerschlĂźsselung kennt. Der Schutz der Daten soll nicht von der Geheimhaltung des Verfahrens, sondern nur von der Geheimhaltung des SchlĂźssels abhängen (Kerckhoffsâ Prinzip).
Weder die BlockgrĂśĂe noch die SchlĂźssellänge darf zu klein sein. Eine BlockgrĂśĂe von 64 bit, die bei älteren Blockchiffren verbreitet ist, ist bereits grenzwertig. Wenn es zu wenig mĂśgliche Blockwerte gibt (hier 2 64 {\displaystyle 2^{64}} ), dann ist ein Codebuchangriff mĂśglich. Ein Angreifer sammelt mĂśglichst viele Paare von Klar- und SchlĂźsseltextblĂścken fĂźr einen bestimmten SchlĂźssel, und wenn einer dieser SchlĂźsseltextblĂścke in irgendeiner Nachricht auftaucht (und der SchlĂźssel nicht inzwischen geändert wurde), kennt er damit auch den Klartextblock. Ist andererseits der SchlĂźssel zu klein, dann ist das Durchprobieren aller mĂśglichen SchlĂźssel praktikabel, um den richtigen zu finden. Moderne Verfahren verwenden mindestens 128 bit als Block- wie auch als SchlĂźssellänge.
Geschichte
Lucifer gilt als die erste zivil nutzbare Blockchiffre, sie wurde im Jahr 1971 von IBM auf der Grundlage von Horst Feistels kryptographischen Arbeiten entwickelt. Eine revidierte Version von Lucifer wurde vom National Bureau of Standards (NBS) der USA (woraus 1988 das National Institute of Standards and Technology, NIST hervorging) Ăźbernommen und zum DES (Data Encryption Standard) erklärt, nachdem Ănderungen vom NBS selbst und vom Geheimdienst NSA am Algorithmus vorgenommen worden waren. Der DES wurde 1976 der Ăffentlichkeit vorgestellt und fand eine weit verbreitete Anwendung. Die BlockgrĂśĂe des DES ist 64 Bit und die SchlĂźssellänge 56 Bit.
Bereits Ende der 90er Jahre konnte DES aufgrund seiner geringen SchlĂźssellänge durch Brute-Force-Angriffe gebrochen werden (siehe EFF DES Cracker). FĂźr eine Ăbergangszeit nutzte man deshalb Modifikationen des DES, wie etwa Triple-DES. Im Jahr 2001 wurde der DES nach einer fĂźnfjährigen Ausschreibungsphase durch den AES (Advanced Encryption Standard) ersetzt. Der Auswahlprozess des AES wird weltweit von vielen Kryptographen wegen seiner offenen Gestaltung als vorbildlich angesehen. Der Algorithmus des AES war von Joan Daemen und Vincent Rijmen unter dem Namen Rijndael entwickelt worden. Die BlockgrĂśĂe beträgt 128 Bit und die SchlĂźssellänge 128, 192 oder 256 Bit, vom Anwender wählbar.
Mathematische Beschreibung
Eine Blockchiffre ist eine Funktion
F : S Ă Ă K â â C : ( s , k ) ⌠⌠F s ( k ) = c {\displaystyle F:S\times K\rightarrow C:(s,k)\mapsto F_{s}(k)=c} ,
die einen Klartextblock k â â K {\displaystyle k\in K} auf einen Geheimtextblock c â â C {\displaystyle c\in C} abbildet, mit dem SchlĂźssel s â â S {\displaystyle s\in S} als Parameter. FĂźr jeden mĂśglichen SchlĂźssel muss die VerschlĂźsselungsfunktion F s : K â â C {\displaystyle F_{s}:K\rightarrow C} injektiv sein, da genau dann eine EntschlĂźsselungsfunktion F â â 1 : S Ă Ă C â â K {\displaystyle F^{-1}:S\times C\rightarrow K} existiert, die zu jedem Geheimtext wieder den Klartext berechnet:
â â s â â S , k â â K : F s â â 1 ( F s ( k ) ) = k {\displaystyle \forall s\in S,k\in K:F_{s}^{-1}(F_{s}(k))=k} .
Dies ist gleichbedeutend zu der Aussage, dass die EntschlĂźsselungsfunktion linksinvers zur VerschlĂźsselungsfunktion ist.
Meist ist K = C {\displaystyle K=C} , und die Ver- und EntschlĂźsselungsfunktionen sind dann fĂźr jeden SchlĂźssel aus S bijektiv. Heute verwendet man auĂerdem fast ausschlieĂlich Bitblockchiffren, die auf BlĂścken mit b Bit arbeiten: K = C = { 0 , 1 } b {\displaystyle K\!\,=C=\{0,1\}^{b}} . Die BlockgrĂśĂe beträgt meist 64 oder 128 Bit, aber grĂśĂere Werte kommen ebenfalls vor (z. B. Threefish; bis 1024 Bit).
Eine Blockchiffre heiĂt involutorisch, wenn Ver- und EntschlĂźsselung identisch sind, also wenn gilt:
â â s â â S , k â â K : F s ( F s ( k ) ) = k {\displaystyle \forall s\in S,k\in K:F_{s}(F_{s}(k))=k} .
Eine bijektive Abbildung von { 0 , 1 } b {\displaystyle \{0,1\}^{b}} auf { 0 , 1 } b {\displaystyle \{0,1\}^{b}} ist eine Permutation von 2 b {\displaystyle 2^{b}} Elementen. Es gibt folglich eine extrem groĂe Zahl ( 2 b ! {\displaystyle 2^{b}!} ) verschiedener Abbildungen (siehe Fakultät).
Durch den SchlĂźssel einer Blockchiffre wird von den 2 b ! {\displaystyle 2^{b}!} mĂśglichen bijektiven Abbildungen genau eine ausgewählt. Da die SchlĂźssellänge typischer Blockchiffren weit geringer als log 2 ⥠⥠( 2 b ! ) {\displaystyle \log _{2}(2^{b}!)} Bits ist, wird durch die Gesamtheit aller SchlĂźssel nur ein kleiner Teil aller mĂśglichen Abbildungen erfasst. Bereits bei einer BlockgrĂśĂe von nur 8 Bit wäre ein 1684 Bit langer SchlĂźssel nĂśtig, um alle Permutationen zu realisieren.
Entwurfsprinzipien
Fßr die interne Verarbeitung der Blockdaten gibt es zwei Ziele: Durch Konfusion soll der Zusammenhang zwischen Geheim- und Klartext so komplex und undurchschaubar wie mÜglich gemacht werden. Diffusion soll die Information an einer Stelle des Klartextblocks ßber den gesamten Geheimtextblock verteilen; am Ende soll jedes Bit des Geheimtextblocks von jedem Bit des Klartextblocks und des Schlßssels abhängen. Wenn an diesen etwas geändert wird, soll sich jedes Geheimtextbit mit der Wahrscheinlichkeit 1/2 ändern. Es sollen keine Muster erkennbar sein, mit denen man aus einem Geheimtext irgendwelche Informationen ßber den Klartext oder den Schlßssel gewinnen kÜnnte.
Die Schwierigkeit, eine VerschlĂźsselung zu entwickeln, liegt darin, eine umkehrbare Transformation zu finden, welche den kryptographischen Anforderungen (Konfusion und Diffusion) gerecht wird und mit nicht zu hohem Aufwand implementierbar und effizient ausfĂźhrbar ist. Darum versucht man meist nicht, eine komplexe Funktion zu finden, die den Text in einem einzigen Schritt verschlĂźsselt, sondern beschränkt sich auf eine relativ einfach aufgebaute Rundenfunktion. Erst deren mehrfache Anwendung ergibt eine ausreichend komplexe VerschlĂźsselungsfunktion. Die Rundenfunktion bewirkt sowohl Konfusion als auch Diffusion, wodurch diese während der VerschlĂźsselung wirksam miteinander verzahnt werden. Es werden genĂźgend Runden durchlaufen, um den Datenblock mehrmals vollständig zu durchmischen, meist etwa 8 bis 64 Runden. Die Rundenfunktion wird auĂerdem so aufgebaut, dass sich die Diffusionseigenschaften zwischen Ver- und EntschlĂźsselung nicht wesentlich unterscheiden und somit auch beim EntschlĂźsseln eine gute Diffusion besteht.
Die aufeinanderfolgenden Runden sollten nicht exakt gleich arbeiten, da das Verfahren sonst fßr den sogenannten Slide-Angriff (engl. slide attack) anfällig wäre.cite-ref-biryukov-wagner-1-0[1] Deshalb berechnet man ßblicherweise aus dem Benutzerschlßssel mehrere verschiedene Rundenschlßssel, und in jeder Runde wird ein anderer davon mit dem Datenblock verknßpft, entweder als zweite Eingabe in die Rundenfunktion:
k i = f ( k i â â 1 , g ( s , i ) ) {\displaystyle k_{i}=f(k_{i-1},g(s,i))} ,
oder zwischen den Anwendungen der Rundenfunktion, z. B. durch bitweise XOR-VerknĂźpfung:
k i = f ( k i â â 1 â â g ( s , i ) ) {\displaystyle k_{i}=f(k_{i-1}\oplus g(s,i))}
mit Rundennummer i â â { 1 , 2 , ⯠⯠, r } {\displaystyle i\in \{1,2,\cdots ,r\}} . Dabei ist f {\displaystyle f} die Rundenfunktion, k 0 {\displaystyle k_{0}} der Klartext, k r {\displaystyle k_{r}} der Geheimtext, s {\displaystyle s} der BenutzerschlĂźssel und g {\displaystyle g} die SchlĂźsseleinteilungsfunktion, die die einzelnen RundenschlĂźssel liefert. Sich zyklisch alle x < r {\displaystyle x<r} Runden wiederholende RundenschlĂźssel g ( s , i ) = g ( s , i + x ) {\displaystyle g(s,i)=g(s,i+x)} sollten vermieden werden, da dies ebenfalls einen Slide-Angriff ermĂśglichen wĂźrde.
AuĂerdem ist es ungĂźnstig, wenn Abschnitte der VerschlĂźsselung (eine oder einige aufeinanderfolgende Runden) mit zu wenig SchlĂźsseldaten erfolgen, da das Verfahren dann fĂźr den Meet-in-the-middle-Angriff anfällig wäre. Das kann sich beispielsweise dadurch ergeben, dass die während der ersten Hälfte der VerschlĂźsselung (Runden i = 1 {\displaystyle i=1} bis r / 2 {\displaystyle r/2} ) verwendeten RundenschlĂźssel nur von einer Hälfte des BenutzerschlĂźssels abhängen und die restlichen RundenschlĂźssel ( i = r / 2 + 1 {\displaystyle i=r/2+1} bis r {\displaystyle r} ) nur von der zweiten Hälfte. Die RundenschlĂźssel sollten ausreichend viele und ausreichend lang sein und jeder RundenschlĂźssel sollte vom gesamten BenutzerschlĂźssel (statt nur von einem Teil davon) abhängen. Idealerweise ist die SchlĂźsseleinteilungsfunktion g {\displaystyle g} ein Hashprozess, der die RundenschlĂźssel auf komplexe, pseudozufällige Weise aus dem BenutzerschlĂźssel berechnet.
Damit man die Implementierung einer Chiffre gut gegen Seitenkanalangriffe absichern kann, sollte die Art und die Reihenfolge der beim VerschlĂźsseln ablaufenden Operationen nicht vom SchlĂźssel oder vom Klartext abhängen. Nur die Werte der Operanden sollten sich jeweils ändern. Ein Angreifer, der den Ablauf von auĂen verfolgen kann, etwa indem er die Zeit eines VerschlĂźsselungsvorgangs misst, soll keine RĂźckschlĂźsse auf die verarbeiteten Daten ziehen kĂśnnen. Wenn zum Beispiel abhängig von einem Bit des SchlĂźssels (bzw. eines RundenschlĂźssels) an einer Stelle entweder eine Addition oder eine Multiplikation zweier Werte erfolgt, dann ist es schwer zu vermeiden, dass diese Operation je nach SchlĂźsselbit unterschiedlich lange dauert und der Prozessor dabei auch unterschiedlich viel Energie verbraucht und das SchlĂźsselbit dadurch von einem Angreifer ermittelt werden kann.
Feistelchiffre
â
Hauptartikel
:
Feistelchiffre
Das Feistelnetzwerk ist eine allgemeine Struktur, mit der Blockchiffren realisiert werden kĂśnnen. Horst Feistel, der im Jahr 1970 bei IBM an der Chiffre Lucifer arbeitete, gilt als Erfinder. Ein Klartextblock wird in zwei Teile geteilt und in mehreren Runden verarbeitet. In jeder Runde wird ein Blockteil zusammen mit einem RundenschlĂźssel in die Rundenfunktion eingegeben und deren Ausgabe mit dem anderen Blockteil verknĂźpft. Feistelnetzwerke ermĂśglichen eine EntschlĂźsselung, ohne dass die Umkehrung der Rundenfunktion berechnet werden muss. Viele Chiffren, zum Beispiel DES, Twofish und Blowfish, sind als Feistelnetzwerke aufgebaut.
Lai-Massey-Chiffre
Hier nutzt man, ähnlich wie beim Feistelnetzwerk, eine Rundenfunktion f {\displaystyle f} auf eine Weise, dass man beim Entschlßsseln nicht ihre Umkehrung berechnen muss. Der Datenblock wird in zwei Hälften a , b {\displaystyle a,b} geteilt. In jeder Runde verknßpft man beide Hälften miteinander, gibt das Ergebnis in die Rundenfunktion ein und verknßpft dann deren Ausgabe mit jeder der Blockhälften:
a Ⲡ= a â â f ( a â â b ) ; b Ⲡ= b â â f ( a â â b ) {\displaystyle a'=a\oplus f(a\ominus b);\;b'=b\oplus f(a\ominus b)} .
Das geschieht so, dass a Ⲡâ â b Ⲡ= a â â b {\displaystyle a'\ominus b'=a\ominus b} ist und man somit bei Wiederholung der Operation wieder die gleiche Eingabe in f {\displaystyle f} erhält. So ist es leicht, die Runde rĂźckgängig zu machen. Am einfachsten geht das, indem man fĂźr â â {\displaystyle \oplus } und â â {\displaystyle \ominus } jeweils das bitweise XOR einsetzt. Eine weitere MĂśglichkeit ist, fĂźr â â {\displaystyle \ominus } die Subtraktion zu verwenden, und fĂźr â â {\displaystyle \oplus } beim VerschlĂźsseln die Addition und beim EntschlĂźsseln die Subtraktion (oder umgekehrt), jeweils modulo 2 b {\displaystyle 2^{b}} , wobei b {\displaystyle b} die Wortbreite in Bit ist.
Damit sich die aufeinanderfolgenden Runden beim Verschlßsseln nicht gegenseitig schwächen oder aufheben, muss der Datenblock zwischen den Runden mit einer weiteren Operation modifiziert werden. Dazu werden häufig die Bits einer Blockhälfte permutiert, z. B. durch Bitrotation.
Substitutions-Permutations-Netzwerk
â
Hauptartikel
:
Substitutions-Permutations-Netzwerk
Die Runden eines Substitutions-Permutations-Netzwerks sind dreiteilig: Zuerst wird der RundenschlĂźssel mit dem Datenblock verknĂźpft. Dann wird eine n Ă Ă n {\displaystyle n\times n} SâBox auf den Datenblock angewendet, der dazu in Teile von n {\displaystyle n} Bit geteilt wird, die fĂźr sich substituiert werden. Danach werden die Bits des Datenblocks permutiert, so dass die Ausgabe einer SâBox sich in der nächsten Runde auf mehrere SâBoxen und schlieĂlich Ăźber den ganzen Datenblock verteilt. Oft wird diese Permutation durch eine komplexere Operation ersetzt, wie z. B. bei Serpent und AES, um die Diffusion zu beschleunigen. In der letzten Runde ist die Permutation ĂźberflĂźssig, stattdessen wird noch einmal mit einem RundenschlĂźssel verknĂźpft.
Zur EntschlĂźsselung mĂźssen diese drei Schritte invertiert werden. Die SâBox muss bijektiv sein, und beim EntschlĂźsseln muss die dazu inverse SâBox eingesetzt werden.
Primitive
Als Einzeloperationen in der Rundenfunktion (sog. kryptographische Primitive) werden meistens solche gewählt, die von den verbreiteten Mikroprozessoren durch einen einzigen Maschinenbefehl schnell ausfßhrbar sind, damit sich die Verschlßsselung einfach und effizient in Software programmieren lässt:
⢠Addition, Subtraktion und Multiplikation von Ganzzahlen modulo 2 w {\displaystyle 2^{w}} , wobei w {\displaystyle w} die Breite eines Datenwortes in Bit ist
⢠bitweise boolesche Verknßpfungen: UND, ODER, XOR, NICHT
⢠Bitrotation
⢠Bitverschiebung
Viele moderne Blockchiffren sind sogenannte ARX-Chiffren, wie etwa Threefish. Das bedeutet, sie sind nur aus Addition, Rotation mit konstanter Weite und XOR aufgebaut. Dadurch sind sie einfach implementierbar und effizient, obwohl meist viele Runden fßr eine ausreichende Stärke der Verschlßsselung nÜtig sind.
S-Boxen sind in Software weniger effizient zu implementieren, aber sie sind auch starke Konfusionserzeuger und somit kryptographisch sehr wirksam, denn man kann (weitgehend) frei bestimmen, wie die a {\displaystyle a} eingegebenen Bits von einer a à à b {\displaystyle a\times b} S-Box auf die b {\displaystyle b} Ausgabebits abgebildet werden. S-Boxen kÜnnen konstant (DES, AES, CAST) oder schlßsselabhängig (Blowfish) sein.
Im Hinblick auf die Implementierung in Hardware nutzt man in vielen Chiffren auch die Permutation von Bits (reichlich z. B. bei DES), die sich hier einfach realisieren lässt, man muss nur jede Bit-Leitung an den richtigen Eingang des nachfolgenden Gatters legen. Bei Software-Implementierung sind allgemeine Bitpermutationen hingegen ungeschickt, man muss das Datenwort in einzelne Bits zerteilen, diese verschieben und neu zusammensetzen. Meist lässt sich das am einfachsten als SâBox darstellen, die z. B. immer 8 Bit durch ein ganzes Wort ersetzt, das die eingegebenen Bits an den richtigen Positionen enthält, wonach diese WĂśrter durch bitweises ODER zusammengesetzt werden. Eine Substitution mit anschlieĂender Bitpermutation kann mit dieser Technik zu einer Operation zusammengefasst werden.
Kryptographische Betriebsmodi
â
Hauptartikel
:
Betriebsmodus (Kryptographie)
Ein kryptographischer Betriebsmodus legt fest, wie sich die Verschlßsselung mehrerer KlartextblÜcke vollzieht, indem er definiert, in welcher Art der Verschlßsselungsalgorithmus auf den Datenstrom angewandt wird.cite-ref-schneier-2-0[2] Je nach den Anforderungen der Anwendung variiert die Fehleranfälligkeit und Sicherheit. Der internationale Standard ISO 10116 definiert fßr blockorientierte Verschlßsselungsalgorithmen vier verschiedenen Betriebsarten:
⢠Electronic Code Book (ECB): Jeder Block wird fßr sich verschlßsselt.
⢠Cipher Block Chaining (CBC): Jeder Block wird mit dem vorherigen Geheimtextblock XOR-verknßpft, bevor man ihn verschlßsselt.
⢠Cipher Feedback (CFB): Ein Geheimtextblock entsteht durch XOR des Klartextblocks mit dem nochmals verschlßsselten vorherigen Geheimtextblock.
⢠Output Feedback (OFB): Die Blockchiffre wird wie eine Stromchiffre eingesetzt, indem ein Initialisierungsvektor immer wieder ßberschlßsselt wird, um damit jeweils den nächsten Klartextblock per XOR zu verknßpfen.
AuĂerdem gibt es den Counter Mode (CTR), bei dem eine Nonce zusammen mit der Nummer eines Blocks verschlĂźsselt wird. Das Ergebnis wird nach Art einer StromverschlĂźsselung mit diesem Block XOR-verknĂźpft.
Einige neuere BlockverschlĂźsselungen, wie z. B. Threefish, nehmen eine zusätzliche Eingabe, den sogenannten Tweak, entgegen, der die Abbildung des Klartextes auf den SchlĂźsseltext beeinflusst. Auf Englisch nennt man sie tweakable block ciphers; eine deutsche Ăbersetzung hat sich bisher nicht verbreitet. Bei Ănderung des Tweak ändert sich die Permutation der Blockwerte, ebenso wie bei Ănderung des SchlĂźssels. Während aber letztere durch die komplexe SchlĂźsseleinteilung vieler Chiffren aufwändig ist (ein extremes Beispiel ist Blowfish), kann der Tweak sehr einfach und schnell geändert werden. Dadurch werden weitere Betriebsmodi mĂśglich. So kann man ECB derart modifizieren, dass jeder Block mit einem anderen Tweak (aber gleichem SchlĂźssel) verschlĂźsselt wird. Der Tweak muss nicht geheim gehalten werden, und man kann dafĂźr z. B. einfach die laufende Nummer des Blocks verwenden. Dadurch werden gleiche KlartextblĂścke nicht mehr auf gleiche GeheimtextblĂścke abgebildet.
Auch Blockchiffren, die an sich nicht tweak-bar sind, kĂśnnen durch Wahl eines geeigneten Betriebsmodus mit einem Tweak verschlĂźsseln. Das nutzt man zum Beispiel bei XTS-AES.
Bekannte Blockchiffren
Einige bekannte Blockchiffren sind:
⢠Camellia
⢠RC2
⢠Data Encryption Standard (DES)
⢠Triple-DES (3DES)
⢠International Data Encryption Algorithm (IDEA)
⢠IDEA NXT (FOX)
⢠RC5
⢠RC6
⢠MARS
⢠Serpent
⢠Advanced Encryption Standard (AES)
⢠CAST
⢠Blowfish
⢠Twofish
⢠Threefish
⢠Skipjack
⢠FEAL
⢠Tiny Encryption Algorithm (TEA)
⢠Extended Tiny Encryption Algorithm (XTEA)
⢠SEED
Weblinks
⢠Klaus Pommerening: Bitblock-Verschlßsselung. (PDF; 712 kB) Fachbereich Mathematik der Johannes-Gutenberg-Universität
⢠Stefan Labitzke, Sven Kampfhenkel: Sicherheitsaspekte in der Softwaretechnik. (PDF; 1,7 MB), Fakultät IV Informatik der TU Berlin
Einzelnachweise